home *** CD-ROM | disk | FTP | other *** search
/ Just Call Me Internet / Just Call Me Internet.iso / prog / atari / c / nos042_s / ttydriv.c < prev    next >
C/C++ Source or Header  |  1994-09-16  |  4KB  |  227 lines
  1. /* TTY input line editing
  2.  * Copyright 1991 Phil Karn, KA9Q
  3.  *
  4.  * ATARI Version by David Nash - dnash@chaos.demon.co.uk
  5.  */
  6. #include <stdio.h>
  7. #include "global.h"
  8. #include "mbuf.h"
  9. #include "session.h"
  10. #include "tty.h"
  11. #include "socket.h"
  12.  
  13. extern FILE *Rawterm;
  14.  
  15. #define    OFF    0
  16. #define    ON    1
  17.  
  18. #define    LINESIZE    256
  19.  
  20. #ifndef ATARI
  21. #define    CTLU    21
  22. #define CTLR    18
  23. #define    CTLZ    26
  24. #define LEFT    75
  25. #define RIGHT    77
  26. #define UP        72
  27. #define DOWN    80
  28. #define HOME    71
  29. #define END        334
  30. #define BS        0x7f
  31. #define DEL        83
  32. #else
  33. #define    CTLU    21
  34. #define CTLR    18
  35. #define    CTLZ    26
  36. #define LEFT    330
  37. #define RIGHT    332
  38. #define UP        327
  39. #define DOWN    335
  40. #define HOME    326
  41. #define END        334
  42. #define    BS        0x7f
  43. #define DEL        338
  44. #endif
  45.  
  46. /* Accept characters from the incoming tty buffer and process them
  47.  * (if in cooked mode) or just pass them directly (if in raw mode).
  48.  *
  49.  * Echoing (if enabled) is direct to the raw terminal. This requires
  50.  * recording (if enabled) of locally typed info to be done by the session
  51.  * itself so that edited output instead of raw input is recorded.
  52.  */
  53.  
  54. struct mbuf *ttydriv(
  55.     struct session *sp,
  56.     int c )
  57. {
  58.     struct mbuf *bp;
  59.     char *cp,*rp, cc;
  60.     int dif, i;
  61.     cc = c % 256;
  62.  
  63.     switch(sp->ttystate.edit) {
  64.     case OFF:
  65.         bp = ambufw(1);
  66.         *bp->data = cc;
  67.         bp->cnt = 1;
  68.  
  69.         if(sp->ttystate.echo)
  70.             putc(c,Rawterm);
  71.  
  72.         return bp;
  73.  
  74.     case ON:
  75.         if(sp->ttystate.line == NULLBUF)
  76.             sp->ttystate.line = ambufw(LINESIZE);
  77.  
  78.         bp  = sp->ttystate.line;
  79.         cp  = bp->data + sp->cur_pos;
  80.         dif = bp->cnt - sp->cur_pos;
  81.  
  82.         /* Perform cooked-mode line editing */
  83.  
  84.         switch(c) {
  85.         case '\r':                                    /* CR & LF both terminate line     */
  86.         case '\n':
  87.             if(sp->ttystate.crnl)
  88.                 *(cp + dif) = '\n';
  89.             else
  90.                 *(cp + dif) = cc;
  91.                 
  92.             if(sp->ttystate.echo)
  93.                 fputs(Eol,Rawterm);
  94.                 
  95.             bp->cnt += 1;
  96.             sp->ttystate.line = NULLBUF;
  97.             return bp;
  98.  
  99.         case DEL:
  100. #if 0
  101.             if (dif == 0)
  102.                 break;
  103.  
  104.             /* Forward a character */
  105.  
  106.             sp->cur_pos++;
  107.             dif--;
  108.             cp++;
  109.             putc(' ', Rawterm);
  110. #endif
  111.             if (sp->cur_pos < bp->cnt)    {
  112.                 sp->cur_pos++;
  113.             }    
  114.             /* Now drop through to delete backwards */
  115.  
  116.         case BS:
  117.         case '\b':    /* Character delete */
  118.             if(sp->cur_pos)    {
  119.                 bp->cnt--;
  120.                 sp->cur_pos--;
  121.  
  122.                 if(sp->ttystate.echo)
  123.                     fputs("\b \b",Rawterm);
  124.  
  125.                 if (dif)    {
  126.                     memmove(cp - 1, cp, dif);
  127.                     if(sp->ttystate.echo)    {
  128.                         for (i = 0; i < dif; i++)
  129.                             putc(*(cp + i - 1), Rawterm);
  130.                         putc(' ', Rawterm);
  131.                         for (i = 0; i <= dif; i++)
  132.                             fputs("\b", Rawterm);
  133.                     }
  134.                 }
  135.             }
  136.             break;
  137.  
  138.         case CTLR:                                    /* print line buffer                 */
  139.             if(sp->ttystate.echo)
  140.                 {
  141.                 fprintf(Rawterm,"^R%s",Eol);
  142.                 rp = bp->data;
  143.                 while (rp < cp)
  144.                     putc(*rp++,Rawterm);
  145.                 }
  146.             break ;
  147.         case CTLU:                                    /* Line kill                             */
  148.             while (dif--)
  149.                 putc(' ', Rawterm);
  150.                 
  151.             while(bp->cnt != 0)    {
  152.                 bp->cnt--;
  153.  
  154.                 if(sp->ttystate.echo)
  155.                     fputs("\b \b",Rawterm);
  156.             }
  157.  
  158.             sp->cur_pos = 0;
  159.             break;
  160.  
  161.         case LEFT:        /* Cursor left */
  162.             if (sp->cur_pos > 0)    {
  163.                 sp->cur_pos--;
  164.                 fputs("\b",Rawterm);
  165.             }
  166.             break;
  167.  
  168.         case RIGHT:    /* Cursor right */
  169.             if (sp->cur_pos < bp->cnt)    {
  170.                 sp->cur_pos++;
  171.                 
  172.                 if(sp->ttystate.echo)
  173.                     putc(*cp, Rawterm);
  174.             }
  175.             break;
  176.  
  177.         case HOME:                                    /* Back to start of line             */
  178.             while (sp->cur_pos) {
  179.                 sp->cur_pos--;
  180.                 
  181.                 if(sp->ttystate.echo)
  182.                     fputs("\b", Rawterm);
  183.             }
  184.             break;
  185.  
  186.         case END:                                    /* Go to end of line                 */
  187.             for (i = 0; i < dif; i++) {
  188.                 if(sp->ttystate.echo)
  189.                     putc(*(cp + i), Rawterm);
  190.                     
  191.                 sp->cur_pos++;
  192.             }
  193.             break;
  194.  
  195.         case UP:                                        /* Previous line                         */
  196.             break;
  197.  
  198.         case DOWN:                                    /* Next line                             */
  199.             break;
  200.  
  201.         default:                                        /* Ordinary character                 */
  202.             if (dif)
  203.                 memmove(cp + 1, cp, dif);
  204.             *cp = cc;
  205.             bp->cnt++;
  206.             sp->cur_pos++;
  207.  
  208.             if (sp->ttystate.echo && bp->cnt < LINESIZE-1) {
  209.                 putc(cc,Rawterm);
  210.                 if (dif) {
  211.                     for (i = 0; i < dif; i++)
  212.                         putc(*(cp + i + 1), Rawterm);
  213.                     for (i = 0; i < dif; i++)
  214.                         fputs("\b", Rawterm);
  215.                 }
  216.             }
  217.             else if(bp->cnt >= LINESIZE-1) {
  218.                 putc('\007',Rawterm);            /* Beep                                     */
  219.                 bp->cnt--;
  220.             }
  221.             break;
  222.         }
  223.         break;
  224.     }
  225.     return NULLBUF;
  226. }
  227.